#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
JobsDB 自动化操作主程序
功能：自动登录、搜索、筛选、联系候选人
使用方法：python jobsdb_auto.py [参数]
"""

import os
import sys
import time
import argparse
import logging
import traceback
import random
from datetime import datetime

# 设置Django环境
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'walmart_project.settings')
import django
django.setup()

# 导入项目模块
from app.interface_zhipin.jobsdb_automation import JobsDBAutomation
from app.interface_zhipin.deep1 import DeepSeekEnhanced, analyze_interest_with_deepseek
from app.interface_zhipin.learning_system import LearningSystem
from app.interface_zhipin.response_system import ResponseGenerator
from app.interface_zhipin.knowledge_manager import KnowledgeBase
from app.models import ChatHistory

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f"jobsdb_auto_{datetime.now().strftime('%Y%m%d')}.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger('jobsdb_auto')

# API密钥（生产环境中应该使用环境变量或安全存储）
DEEPSEEK_API_KEY = "sk-048e7d7e52344cdf8a03d90429ed0d6f"  # 替换为实际API密钥


class JobsDBAutoRunner:
    """JobsDB自动化运行器"""

    def __init__(self, args):
        self.args = args
        self.automation = JobsDBAutomation()
        self.ai_assistant = DeepSeekEnhanced(DEEPSEEK_API_KEY)
        self.learning_system = LearningSystem()
        self.response_gen = ResponseGenerator()
        
        # 初始化会话统计
        self.stats = {
            'contacts_processed': 0,
            'messages_sent': 0,
            'responses_received': 0,
            'errors': 0
        }
        
        logger.info(f"初始化完成，运行模式: {args.mode}")

    def run(self):
        """主运行逻辑"""
        try:
            # 1. 登录系统
            if not self.args.skip_login:
                logger.info("开始登录JobsDB...")
                self.automation.login(self.args.username, self.args.password)
            
            # 2. 根据运行模式选择操作
            if self.args.mode == 'search':
                self._run_search_mode()
            elif self.args.mode == 'contact':
                self._run_contact_mode()
            elif self.args.mode == 'analyze':
                self._run_analyze_mode()
            elif self.args.mode == 'respond':
                self._run_respond_mode()
            elif self.args.mode == 'full':
                self._run_full_workflow()
            else:
                logger.error(f"未知的运行模式: {self.args.mode}")
                
            # 3. 显示统计信息
            self._display_stats()
                
        except Exception as e:
            logger.error(f"运行过程中发生错误: {str(e)}")
            logger.error(traceback.format_exc())
            self.stats['errors'] += 1
        finally:
            # 4. 关闭浏览器会话
            if not self.args.keep_open:
                logger.info("正在关闭浏览器会话...")
                self.automation.close()
    
    def _run_search_mode(self):
        """搜索模式：搜索并保存候选人信息"""
        logger.info(f"开始搜索模式，关键词: {self.args.keywords}")
        
        # 搜索候选人
        results = self.automation.search_candidates(
            keywords=self.args.keywords.split(','),
            location=self.args.location,
            experience=self.args.experience,
            max_pages=self.args.max_pages
        )
        
        logger.info(f"搜索完成，找到 {len(results)} 名候选人")
        
        # 可选：保存到数据库
        if not self.args.no_save:
            saved = self.automation.save_candidates(results)
            logger.info(f"已保存 {saved} 名候选人信息到数据库")
    
    def _run_contact_mode(self):
        """联系模式：向候选人发送消息"""
        logger.info("开始联系模式...")
        
        # 获取待联系候选人列表
        candidates = self.automation.get_candidates_to_contact(
            limit=self.args.contact_limit,
            min_days=self.args.contact_interval
        )
        
        logger.info(f"找到 {len(candidates)} 名待联系候选人")
        
        # 联系候选人
        for candidate in candidates:
            try:
                # 获取合适的消息模板
                message = self.response_gen.generate_initial_message(
                    name=candidate.get('name', ''),
                    position=candidate.get('position', ''),
                    company=candidate.get('company', '')
                )
                
                # 发送消息
                sent = self.automation.send_message(
                    candidate_id=candidate.get('id'),
                    message=message
                )
                
                if sent:
                    logger.info(f"成功联系候选人: {candidate.get('name')}")
                    self.stats['messages_sent'] += 1
                else:
                    logger.warning(f"联系候选人失败: {candidate.get('name')}")
                
                # 防止操作过快
                time.sleep(random.uniform(3.0, 5.0))
                
            except Exception as e:
                logger.error(f"联系候选人 {candidate.get('name')} 时出错: {str(e)}")
                self.stats['errors'] += 1
            
            self.stats['contacts_processed'] += 1
    
    def _run_analyze_mode(self):
        """分析模式：分析聊天记录"""
        logger.info("开始分析模式...")
        
        # 获取未分析的聊天记录
        chats = ChatHistory.objects.filter(analysis_result__isnull=True).order_by('-created_at')[:self.args.analyze_limit]
        
        logger.info(f"找到 {len(chats)} 条未分析的聊天记录")
        
        # 分析聊天记录
        for chat in chats:
            try:
                # 解析聊天内容
                messages = self._parse_chat_content(chat.chat_content)
                
                # 使用DeepSeek分析
                result = analyze_interest_with_deepseek(
                    messages=messages,
                    contact_info={
                        'name': chat.contact_name,
                        'company': chat.company_name,
                        'position': chat.position
                    }
                )
                
                # 更新分析结果
                chat.analysis_result = result.get('analysis', '')
                chat.is_interested = result.get('interested', False)
                chat.need_followup = result.get('need_followup', True)
                chat.save()
                
                logger.info(f"成功分析聊天记录: {chat.id} - {chat.contact_name}")
                self.stats['responses_received'] += 1
                
            except Exception as e:
                logger.error(f"分析聊天记录 {chat.id} 时出错: {str(e)}")
                self.stats['errors'] += 1
    
    def _run_respond_mode(self):
        """回复模式：生成并发送回复"""
        logger.info("开始回复模式...")
        
        # 获取需要回复的对话
        chats = ChatHistory.objects.filter(
            need_followup=True, 
            last_response_at__isnull=True
        ).order_by('-created_at')[:self.args.respond_limit]
        
        logger.info(f"找到 {len(chats)} 条需要回复的对话")
        
        # 生成并发送回复
        for chat in chats:
            try:
                # 解析聊天内容
                messages = self._parse_chat_content(chat.chat_content)
                
                # 生成回复
                response = self.response_gen.generate_response(
                    messages=messages,
                    contact_name=chat.contact_name,
                    is_interested=chat.is_interested
                )
                
                # 发送回复
                if not self.args.dry_run:
                    sent = self.automation.send_message(
                        candidate_id=chat.contact_id,
                        message=response
                    )
                    
                    if sent:
                        # 更新聊天记录
                        chat.last_response_at = datetime.now()
                        chat.last_response = response
                        chat.save()
                        
                        logger.info(f"成功回复: {chat.contact_name}")
                        self.stats['messages_sent'] += 1
                    else:
                        logger.warning(f"回复失败: {chat.contact_name}")
                else:
                    logger.info(f"[DRY RUN] 将回复 {chat.contact_name}: {response[:50]}...")
                
            except Exception as e:
                logger.error(f"回复 {chat.contact_name} 时出错: {str(e)}")
                self.stats['errors'] += 1
            
            self.stats['contacts_processed'] += 1
    
    def _run_full_workflow(self):
        """完整工作流：搜索、联系、分析、回复"""
        logger.info("开始完整工作流...")
        
        # 搜索候选人
        self._run_search_mode()
        
        # 联系候选人
        self._run_contact_mode()
        
        # 分析聊天记录
        self._run_analyze_mode()
        
        # 回复消息
        self._run_respond_mode()
        
        logger.info("完整工作流执行完毕")
    
    def _parse_chat_content(self, content):
        """解析聊天内容为消息列表"""
        messages = []
        if not content:
            return messages
            
        # 简单的解析逻辑，根据实际格式调整
        lines = content.strip().split('\n')
        for line in lines:
            if not line.strip():
                continue
                
            parts = line.split(':', 1)
            if len(parts) != 2:
                continue
                
            sender, message = parts
            sender = sender.strip()
            message = message.strip()
            
            if sender.startswith('对方'):
                messages.append({
                    'sender': 'friend',
                    'message': message,
                    'time': datetime.now().strftime('%H:%M')
                })
            else:
                messages.append({
                    'sender': 'myself',
                    'message': message,
                    'time': datetime.now().strftime('%H:%M')
                })
        
        return messages
    
    def _display_stats(self):
        """显示运行统计信息"""
        logger.info("========== 运行统计 ==========")
        logger.info(f"处理的联系人数量: {self.stats['contacts_processed']}")
        logger.info(f"发送的消息数量: {self.stats['messages_sent']}")
        logger.info(f"收到的回复数量: {self.stats['responses_received']}")
        logger.info(f"发生的错误数量: {self.stats['errors']}")
        logger.info("==============================")


def parse_arguments():
    """解析命令行参数"""
    parser = argparse.ArgumentParser(description='JobsDB自动化操作')
    
    # 登录相关
    parser.add_argument('--username', '-u', help='JobsDB用户名')
    parser.add_argument('--password', '-p', help='JobsDB密码')
    parser.add_argument('--skip-login', action='store_true', help='跳过登录步骤(已有会话)')
    
    # 运行模式
    parser.add_argument('--mode', '-m', default='full',
                        choices=['search', 'contact', 'analyze', 'respond', 'full'],
                        help='运行模式')
    
    # 搜索相关
    parser.add_argument('--keywords', '-k', help='搜索关键词(逗号分隔)')
    parser.add_argument('--location', '-l', help='位置筛选')
    parser.add_argument('--experience', '-e', help='经验年限')
    parser.add_argument('--max-pages', type=int, default=5, help='最大搜索页数')
    parser.add_argument('--no-save', action='store_true', help='不保存搜索结果')
    
    # 联系相关
    parser.add_argument('--contact-limit', type=int, default=20, help='最大联系人数')
    parser.add_argument('--contact-interval', type=int, default=7, help='最小联系间隔(天)')
    
    # 分析相关
    parser.add_argument('--analyze-limit', type=int, default=50, help='最大分析记录数')
    
    # 回复相关
    parser.add_argument('--respond-limit', type=int, default=30, help='最大回复数')
    parser.add_argument('--dry-run', action='store_true', help='不实际发送回复')
    
    # 其他
    parser.add_argument('--keep-open', action='store_true', help='运行完毕后保持浏览器打开')
    
    return parser.parse_args()


if __name__ == '__main__':
    # 解析命令行参数
    args = parse_arguments()
    
    # 启动自动化程序
    runner = JobsDBAutoRunner(args)
    runner.run()
    
    logger.info("JobsDB自动化程序运行完毕")